home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / lang / Long.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  5.7 KB  |  467 lines
  1. package java.lang;
  2.  
  3. public final class Long extends Number implements Comparable<Long> {
  4.    public static final long MIN_VALUE = -9223372036854775808L;
  5.    public static final long MAX_VALUE = 9223372036854775807L;
  6.    public static final Class<Long> TYPE = Class.getPrimitiveClass("long");
  7.    private final long value;
  8.    public static final int SIZE = 64;
  9.    private static final long serialVersionUID = 4290774380558885855L;
  10.  
  11.    public static String toString(long var0, int var2) {
  12.       if (var2 < 2 || var2 > 36) {
  13.          var2 = 10;
  14.       }
  15.  
  16.       if (var2 == 10) {
  17.          return toString(var0);
  18.       } else {
  19.          char[] var3 = new char[65];
  20.          int var4 = 64;
  21.          boolean var5 = var0 < 0L;
  22.          if (!var5) {
  23.             var0 = -var0;
  24.          }
  25.  
  26.          while(var0 <= (long)(-var2)) {
  27.             var3[var4--] = Integer.digits[(int)(-(var0 % (long)var2))];
  28.             var0 /= (long)var2;
  29.          }
  30.  
  31.          var3[var4] = Integer.digits[(int)(-var0)];
  32.          if (var5) {
  33.             --var4;
  34.             var3[var4] = '-';
  35.          }
  36.  
  37.          return new String(var3, var4, 65 - var4);
  38.       }
  39.    }
  40.  
  41.    public static String toHexString(long var0) {
  42.       return toUnsignedString(var0, 4);
  43.    }
  44.  
  45.    public static String toOctalString(long var0) {
  46.       return toUnsignedString(var0, 3);
  47.    }
  48.  
  49.    public static String toBinaryString(long var0) {
  50.       return toUnsignedString(var0, 1);
  51.    }
  52.  
  53.    private static String toUnsignedString(long var0, int var2) {
  54.       char[] var3 = new char[64];
  55.       int var4 = 64;
  56.       int var5 = 1 << var2;
  57.       long var6 = (long)(var5 - 1);
  58.  
  59.       do {
  60.          --var4;
  61.          var3[var4] = Integer.digits[(int)(var0 & var6)];
  62.          var0 >>>= var2;
  63.       } while(var0 != 0L);
  64.  
  65.       return new String(var3, var4, 64 - var4);
  66.    }
  67.  
  68.    public static String toString(long var0) {
  69.       if (var0 == MIN_VALUE) {
  70.          return "-9223372036854775808";
  71.       } else {
  72.          int var2 = var0 < 0L ? stringSize(-var0) + 1 : stringSize(var0);
  73.          char[] var3 = new char[var2];
  74.          getChars(var0, var2, var3);
  75.          return new String(0, var2, var3);
  76.       }
  77.    }
  78.  
  79.    static void getChars(long var0, int var2, char[] var3) {
  80.       int var7 = var2;
  81.       byte var8 = 0;
  82.       if (var0 < 0L) {
  83.          var8 = 45;
  84.          var0 = -var0;
  85.       }
  86.  
  87.       while(var0 > 2147483647L) {
  88.          long var4 = var0 / 100L;
  89.          int var6 = (int)(var0 - ((var4 << 6) + (var4 << 5) + (var4 << 2)));
  90.          var0 = var4;
  91.          --var7;
  92.          var3[var7] = Integer.DigitOnes[var6];
  93.          --var7;
  94.          var3[var7] = Integer.DigitTens[var6];
  95.       }
  96.  
  97.       int var10;
  98.       int var11;
  99.       for(var10 = (int)var0; var10 >= 65536; var3[var7] = Integer.DigitTens[var11]) {
  100.          int var9 = var10 / 100;
  101.          var11 = var10 - ((var9 << 6) + (var9 << 5) + (var9 << 2));
  102.          var10 = var9;
  103.          --var7;
  104.          var3[var7] = Integer.DigitOnes[var11];
  105.          --var7;
  106.       }
  107.  
  108.       int var16;
  109.       do {
  110.          var16 = var10 * 'Ï≥ç' >>> 19;
  111.          var11 = var10 - ((var16 << 3) + (var16 << 1));
  112.          --var7;
  113.          var3[var7] = Integer.digits[var11];
  114.          var10 = var16;
  115.       } while(var16 != 0);
  116.  
  117.       if (var8 != 0) {
  118.          --var7;
  119.          var3[var7] = (char)var8;
  120.       }
  121.  
  122.    }
  123.  
  124.    static int stringSize(long var0) {
  125.       long var2 = 10L;
  126.  
  127.       for(int var4 = 1; var4 < 19; ++var4) {
  128.          if (var0 < var2) {
  129.             return var4;
  130.          }
  131.  
  132.          var2 = 10L * var2;
  133.       }
  134.  
  135.       return 19;
  136.    }
  137.  
  138.    public static long parseLong(String var0, int var1) throws NumberFormatException {
  139.       if (var0 == null) {
  140.          throw new NumberFormatException("null");
  141.       } else if (var1 < 2) {
  142.          throw new NumberFormatException("radix " + var1 + " less than Character.MIN_RADIX");
  143.       } else if (var1 > 36) {
  144.          throw new NumberFormatException("radix " + var1 + " greater than Character.MAX_RADIX");
  145.       } else {
  146.          long var2 = 0L;
  147.          boolean var4 = false;
  148.          int var5 = 0;
  149.          int var6 = var0.length();
  150.          if (var6 > 0) {
  151.             long var7;
  152.             if (var0.charAt(0) == '-') {
  153.                var4 = true;
  154.                var7 = MIN_VALUE;
  155.                ++var5;
  156.             } else {
  157.                var7 = -9223372036854775807L;
  158.             }
  159.  
  160.             long var9 = var7 / (long)var1;
  161.             if (var5 < var6) {
  162.                int var11 = Character.digit(var0.charAt(var5++), var1);
  163.                if (var11 < 0) {
  164.                   throw NumberFormatException.forInputString(var0);
  165.                }
  166.  
  167.                var2 = (long)(-var11);
  168.             }
  169.  
  170.             while(var5 < var6) {
  171.                int var13 = Character.digit(var0.charAt(var5++), var1);
  172.                if (var13 < 0) {
  173.                   throw NumberFormatException.forInputString(var0);
  174.                }
  175.  
  176.                if (var2 < var9) {
  177.                   throw NumberFormatException.forInputString(var0);
  178.                }
  179.  
  180.                var2 *= (long)var1;
  181.                if (var2 < var7 + (long)var13) {
  182.                   throw NumberFormatException.forInputString(var0);
  183.                }
  184.  
  185.                var2 -= (long)var13;
  186.             }
  187.  
  188.             if (var4) {
  189.                if (var5 > 1) {
  190.                   return var2;
  191.                } else {
  192.                   throw NumberFormatException.forInputString(var0);
  193.                }
  194.             } else {
  195.                return -var2;
  196.             }
  197.          } else {
  198.             throw NumberFormatException.forInputString(var0);
  199.          }
  200.       }
  201.    }
  202.  
  203.    public static long parseLong(String var0) throws NumberFormatException {
  204.       return parseLong(var0, 10);
  205.    }
  206.  
  207.    public static Long valueOf(String var0, int var1) throws NumberFormatException {
  208.       return new Long(parseLong(var0, var1));
  209.    }
  210.  
  211.    public static Long valueOf(String var0) throws NumberFormatException {
  212.       return new Long(parseLong(var0, 10));
  213.    }
  214.  
  215.    public static Long valueOf(long var0) {
  216.       return var0 >= -128L && var0 <= 127L ? java.lang.Long.LongCache.cache[(int)var0 + 128] : new Long(var0);
  217.    }
  218.  
  219.    public static Long decode(String var0) throws NumberFormatException {
  220.       byte var1 = 10;
  221.       int var2 = 0;
  222.       boolean var3 = false;
  223.       if (var0.startsWith("-")) {
  224.          var3 = true;
  225.          ++var2;
  226.       }
  227.  
  228.       if (!var0.startsWith("0x", var2) && !var0.startsWith("0X", var2)) {
  229.          if (var0.startsWith("#", var2)) {
  230.             ++var2;
  231.             var1 = 16;
  232.          } else if (var0.startsWith("0", var2) && var0.length() > 1 + var2) {
  233.             ++var2;
  234.             var1 = 8;
  235.          }
  236.       } else {
  237.          var2 += 2;
  238.          var1 = 16;
  239.       }
  240.  
  241.       if (var0.startsWith("-", var2)) {
  242.          throw new NumberFormatException("Negative sign in wrong position");
  243.       } else {
  244.          Long var4;
  245.          try {
  246.             var4 = valueOf(var0.substring(var2), var1);
  247.             var4 = var3 ? new Long(-var4) : var4;
  248.          } catch (NumberFormatException var7) {
  249.             String var6 = var3 ? new String("-" + var0.substring(var2)) : var0.substring(var2);
  250.             var4 = valueOf(var6, var1);
  251.          }
  252.  
  253.          return var4;
  254.       }
  255.    }
  256.  
  257.    public Long(long var1) {
  258.       this.value = var1;
  259.    }
  260.  
  261.    public Long(String var1) throws NumberFormatException {
  262.       this.value = parseLong(var1, 10);
  263.    }
  264.  
  265.    public byte byteValue() {
  266.       return (byte)((int)this.value);
  267.    }
  268.  
  269.    public short shortValue() {
  270.       return (short)((int)this.value);
  271.    }
  272.  
  273.    public int intValue() {
  274.       return (int)this.value;
  275.    }
  276.  
  277.    public long longValue() {
  278.       return this.value;
  279.    }
  280.  
  281.    public float floatValue() {
  282.       return (float)this.value;
  283.    }
  284.  
  285.    public double doubleValue() {
  286.       return (double)this.value;
  287.    }
  288.  
  289.    public String toString() {
  290.       return String.valueOf(this.value);
  291.    }
  292.  
  293.    public int hashCode() {
  294.       return (int)(this.value ^ this.value >>> 32);
  295.    }
  296.  
  297.    public boolean equals(Object var1) {
  298.       if (var1 instanceof Long) {
  299.          return this.value == (Long)var1;
  300.       } else {
  301.          return false;
  302.       }
  303.    }
  304.  
  305.    public static Long getLong(String var0) {
  306.       return getLong(var0, (Long)null);
  307.    }
  308.  
  309.    public static Long getLong(String var0, long var1) {
  310.       Long var3 = getLong(var0, (Long)null);
  311.       return var3 == null ? new Long(var1) : var3;
  312.    }
  313.  
  314.    public static Long getLong(String var0, Long var1) {
  315.       String var2 = null;
  316.  
  317.       try {
  318.          var2 = System.getProperty(var0);
  319.       } catch (IllegalArgumentException var4) {
  320.       } catch (NullPointerException var5) {
  321.       }
  322.  
  323.       if (var2 != null) {
  324.          try {
  325.             return decode(var2);
  326.          } catch (NumberFormatException var6) {
  327.          }
  328.       }
  329.  
  330.       return var1;
  331.    }
  332.  
  333.    public int compareTo(Long var1) {
  334.       long var2 = this.value;
  335.       long var4 = var1.value;
  336.       return var2 < var4 ? -1 : (var2 == var4 ? 0 : 1);
  337.    }
  338.  
  339.    public static long highestOneBit(long var0) {
  340.       var0 |= var0 >> 1;
  341.       var0 |= var0 >> 2;
  342.       var0 |= var0 >> 4;
  343.       var0 |= var0 >> 8;
  344.       var0 |= var0 >> 16;
  345.       var0 |= var0 >> 32;
  346.       return var0 - (var0 >>> 1);
  347.    }
  348.  
  349.    public static long lowestOneBit(long var0) {
  350.       return var0 & -var0;
  351.    }
  352.  
  353.    public static int numberOfLeadingZeros(long var0) {
  354.       if (var0 == 0L) {
  355.          return 64;
  356.       } else {
  357.          int var2 = 1;
  358.          int var3 = (int)(var0 >>> 32);
  359.          if (var3 == 0) {
  360.             var2 += 32;
  361.             var3 = (int)var0;
  362.          }
  363.  
  364.          if (var3 >>> 16 == 0) {
  365.             var2 += 16;
  366.             var3 <<= 16;
  367.          }
  368.  
  369.          if (var3 >>> 24 == 0) {
  370.             var2 += 8;
  371.             var3 <<= 8;
  372.          }
  373.  
  374.          if (var3 >>> 28 == 0) {
  375.             var2 += 4;
  376.             var3 <<= 4;
  377.          }
  378.  
  379.          if (var3 >>> 30 == 0) {
  380.             var2 += 2;
  381.             var3 <<= 2;
  382.          }
  383.  
  384.          var2 -= var3 >>> 31;
  385.          return var2;
  386.       }
  387.    }
  388.  
  389.    public static int numberOfTrailingZeros(long var0) {
  390.       if (var0 == 0L) {
  391.          return 64;
  392.       } else {
  393.          int var4 = 63;
  394.          int var3 = (int)var0;
  395.          int var2;
  396.          if (var3 != 0) {
  397.             var4 -= 32;
  398.             var2 = var3;
  399.          } else {
  400.             var2 = (int)(var0 >>> 32);
  401.          }
  402.  
  403.          var3 = var2 << 16;
  404.          if (var3 != 0) {
  405.             var4 -= 16;
  406.             var2 = var3;
  407.          }
  408.  
  409.          var3 = var2 << 8;
  410.          if (var3 != 0) {
  411.             var4 -= 8;
  412.             var2 = var3;
  413.          }
  414.  
  415.          var3 = var2 << 4;
  416.          if (var3 != 0) {
  417.             var4 -= 4;
  418.             var2 = var3;
  419.          }
  420.  
  421.          var3 = var2 << 2;
  422.          if (var3 != 0) {
  423.             var4 -= 2;
  424.             var2 = var3;
  425.          }
  426.  
  427.          return var4 - (var2 << 1 >>> 31);
  428.       }
  429.    }
  430.  
  431.    public static int bitCount(long var0) {
  432.       var0 -= var0 >>> 1 & 6148914691236517205L;
  433.       var0 = (var0 & 3689348814741910323L) + (var0 >>> 2 & 3689348814741910323L);
  434.       var0 = var0 + (var0 >>> 4) & 1085102592571150095L;
  435.       var0 += var0 >>> 8;
  436.       var0 += var0 >>> 16;
  437.       var0 += var0 >>> 32;
  438.       return (int)var0 & 127;
  439.    }
  440.  
  441.    public static long rotateLeft(long var0, int var2) {
  442.       return var0 << var2 | var0 >>> -var2;
  443.    }
  444.  
  445.    public static long rotateRight(long var0, int var2) {
  446.       return var0 >>> var2 | var0 << -var2;
  447.    }
  448.  
  449.    public static long reverse(long var0) {
  450.       var0 = (var0 & 6148914691236517205L) << 1 | var0 >>> 1 & 6148914691236517205L;
  451.       var0 = (var0 & 3689348814741910323L) << 2 | var0 >>> 2 & 3689348814741910323L;
  452.       var0 = (var0 & 1085102592571150095L) << 4 | var0 >>> 4 & 1085102592571150095L;
  453.       var0 = (var0 & 71777214294589695L) << 8 | var0 >>> 8 & 71777214294589695L;
  454.       var0 = var0 << 48 | (var0 & 4294901760L) << 16 | var0 >>> 16 & 4294901760L | var0 >>> 48;
  455.       return var0;
  456.    }
  457.  
  458.    public static int signum(long var0) {
  459.       return (int)(var0 >> 63 | -var0 >>> 63);
  460.    }
  461.  
  462.    public static long reverseBytes(long var0) {
  463.       var0 = (var0 & 71777214294589695L) << 8 | var0 >>> 8 & 71777214294589695L;
  464.       return var0 << 48 | (var0 & 4294901760L) << 16 | var0 >>> 16 & 4294901760L | var0 >>> 48;
  465.    }
  466. }
  467.